/**
 * 泛型：
 * 在定义函数，接口和类的时候，不预先指定具体的类型而是使用的时候指定
 * 泛型：也像是个参数：
 * */
import {Identifier} from "@babel/types";

function createArray<T>(length: number, value: T): T[] {
    let res = [];
    for (let i = 0; i < length; i++) {
        res[i] = value
    }
    return res;
}

let res = createArray<number>(3, 1);
console.log(res)


//类数组：
function sum(...args: number[]) {
    let args2: IArguments = arguments;
    for (let i = 0; i < args2.length; i++) {
        console.log(args2[i])
    }

}

sum(1, 2, 3);


//泛型类:   (类的静态属性是不能使用泛型类型的)
class MyArray<T> {
    private list: T[] = [];

    add(value: T) {
        this.list.push(value)
        return this.list
    }
}

let arr = new MyArray<number>()
arr.add(1)




//泛型接口：
function identify<T>(arg: T): T {
    return arg
}

interface GeneriticIdentify<T> {
    (arg: T)
}
let demo:GeneriticIdentify<number>=identify


/**
 * 泛型约束
 * 默认情况下不能调用泛型上的任何属性和方法，因为在定义的时候根本不知道会传入什么值
 * 用接口去约束泛型
 * */

interface LengthWise {
    length: number
}

//用LengthWise约束范型，
function logger<T extends LengthWise>(val: T) {
    console.log(val.length)
}

logger<string>('d');


